<article>
    <h1><?php echo $GLOBALS['title'] ?></h1>
    <p>早期编程由于受电脑硬件限制，程序都是追求效率，而忽略可理解性，扩充性，随着硬件技术的发展，编程越来越重视多人开发，程序员越来越重视程序的可靠性，可扩展性，可维护性，所以刺激了程序语言的发展</p>
    <h3>面向过程</h3>
    <p>程序员设计好程序代码流程图，辅助程序设计。优点：用什么功能就编写什么函数	缺点：数据管理上比较混乱，主要集中在函数成面上，面向对象把属性和方法进行封装，更好的可重用性和可扩展性</p>
    <h3>面向对象</h3>
    <p>万物皆对象，将构成问题的事务分解到各个对象上，建立对象的目的不是为了完成一个工作，而是为了描述某个事务在解决问题中的行为，更符合人的思维习惯，代码重用性高，可扩展性好</p>
    <p>在面向对象的程序设计（英语：Object-oriented programming，缩写：OOP）中，对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象。</p>
    <p>在现实世界里我们所面对的事情都是对象，如计算机、电视机、自行车等。</p>
    <h3>对象的主要三个特性：</h3>
    <ol>
    	<li>对象的行为：可以对 对象施加那些操作，开灯，关灯就是行为。</li><p></p>
    	<li>对象的形态：当施加那些方法是对象如何响应，颜色，尺寸，外型。</li><p></p>
    	<li>对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。</li>
    </ol>
    <p>比如 Animal(动物) 是一个抽象类，我们可以具体到一只狗跟一只羊，而狗跟羊就是具体的对象，他们有颜色属性，可以写，可以跑等行为状态。</p>
    <img src="__PUBLIC__/images/animals.png" alt="" width="100%">
    <p><code>注意：</code>对象可以理解为有属性和方法的特殊数据类型。(<code >属性与方法的集合体,通常由类的实例化产生</code>)</p>
    <h2><a>类的概念</a></h2>
    <p>是一种抽象的概念，是具有相同语义定义对象的集合（具有相同属性和方法的集体），使用具体的类是不可行的，只能实例化。拿汽车为例，汽车的设计图纸就是类，汽车是对象。设计中重点是类的创建</p>
    <h3>类名书写规范</h3>
    <p>类名首字母大写, 一个类定义在一个文件中，并以.class.php做为文件名结尾</p>
    <img src="__PUBLIC__/images/classes-and-objects.jpg" alt="" width="100%">
    <pre><code><?php echo htmlspecialchars('
<?php
class phpClass {
  var $var1;
  var $var2 = "constant string";
  
  function myfunc ($arg1, $arg2) {
     [..]
  }
  [..]
}
?>') ?></code></pre>
    <h2><a>对象的产生</a></h2>
    <p>实例化类，产生对象，步骤：</p>
    <ol>
    	<li>在内容中开辟出对象的空间</li><p></p>
    	<li>执行构造方法</li><p></p>
    	<li>将对象的引用地址返回</li>
    </ol>
    <h3>对象句柄</h3>
    <p>用于区分不同对象。对象创建后，在内存中获取一块存储空间，储存空间的地址就是对象的标识或句柄</p>
    <h3>属性</h3>
    <p>在类中定义的变量，即为成员属性，用于描述对象静态特性的数据。 如人的姓名，性别，首字母小写</p>
    <h3>方法</h3>
    <p>函数定义在类中即为成员方法，用于描述对象动态特性的操作行为,方法名不区分大小写，不可重名，首字母小写</p>
    <h3>对象的生命周期</h3>
    <p>创建后，生命周期开始，当程序结束后或程序员清除对象后即销毁，PHP会自动销毁对象</p>
    <pre><code><?php echo htmlspecialchars('
<?php 
class Site { 
  /* 成员变量 */ 
  var $url; 
  var $title; 
   
  /* 成员函数 */ 
  function setUrl($par){ 
     $this->url = $par; 
  } 
   
  function getUrl(){ 
     echo $this->url . PHP_EOL; 
  } 
   
  function setTitle($par){ 
     $this->title = $par; 
  } 
   
  function getTitle(){ 
     echo $this->title . PHP_EOL; 
  } 
} 

$runoob = new Site; 
$taobao = new Site; 
$google = new Site; 

// 调用成员函数，设置标题和URL 
$runoob->setTitle( "菜鸟教程" ); 
$taobao->setTitle( "淘宝" ); 
$google->setTitle( "Google 搜索" ); 

$runoob->setUrl( "www.runoob.com" ); 
$taobao->setUrl( "www.taobao.com" ); 
$google->setUrl( "www.google.com" ); 

// 调用成员函数，获取标题和URL 
$runoob->getTitle(); 
$taobao->getTitle(); 
$google->getTitle(); 

$runoob->getUrl(); 
$taobao->getUrl(); 
$google->getUrl(); 
?>') ?></code></pre>
    <h2><a>构造方法&析构方法</a></h2>
    <h3>构造方法__construct()</h3>
    <p>在创建对象时自动执行，没有返回值，用于执行类的一些初始化工作，如对象属性的初始化工作，PHP4中构造方法必须与类同名，php5中规定构造方法为construct(),优点是不受类名的影响，如果不存在__construct   php搜索与类同名的方法自动执行。</p>
    <h3>析构方法__destruct()</h3>
    <p>用于对象在内存中被销毁时自动执行的方法，不带任何参数</p>
    <h2><a>继承</a></h2>
    <p>可以使一个类继承并拥有另一个已经存在类的成员属性和方法，被继承的类称为父类或基类，继承类为子类。extends关键字实现继承关系。（PHP 不支持多继承）</p>
    <pre><code><?php echo htmlspecialchars('
<?php 
// 子类扩展站点类别
class Child_Site extends Site {
   var $category;

    function setCate($par){
        $this->category = $par;
    }
  
    function getCate(){
        echo $this->category . PHP_EOL;
    }
}') ?></code></pre>
    <h3>方法重写</h3>
    <p>如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。</p>
    <h2><a>访问控制</a></h2>
    <p>PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。</p>
    <ul>
        <li><code>public（公有）：</code>公有的类成员可以在任何地方被访问。</li><p></p>
        <li><code>protected（受保护）：</code>受保护的类成员则可以被其自身以及其子类和父类访问。</li><p></p>
        <li><code>private（私有）：</code>私有的类成员则只能被其定义所在的类访问。</li>
    </ul>
    <h2><a>Static 关键字</a></h2>
    <p>需要一个数据对象只服务于类，即类内部可用，对外不可用时。建对象是极其耗费资源的,因此当一个方法具有比较强的公用性的时候, 没有必要为了调用这个方法而重新再生成该类的实例。定义的方法或变量在程序第一次加载时即驻留内存，程序结束释放。静态方法不能被非静态方法重写，构造方法不允许声明为static的</p>
    <h3>static变量</h3>
    <p>通过static声明的成员变量为静态变量，是该类的公共变量，在第一次使用时即生成，对于该类的所有对象只有一份，是  属于类的，不是属于对象的。static变量是属于类而不属于对象，可以在任何地方通地类来访问，是类的全局变量，类创建时即存入 内存。对多个对象来说，静态数据成员只存储一处，可以节省内存。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值。</p>
    <h3>static方法</h3>
    <p>用static声明的方法为静态方法，执行该方法时不会将对象引用传给函数，所以我们不能访问非静态成员，只能访问静态  方法或静态变量。使用时不用生成对象即可执行</p>
    <pre><code><?php echo htmlspecialchars('
<?php
class Foo {
  public static $my_static = "foo";
  
  public function staticValue() {
     return self::$my_static;
  }
}

print Foo::$my_static . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>') ?></code></pre>
    <h2><a>方法调用</a></h2>
    <h3>$this</h3>
    <p>是当前对象的引用，一般出现在方法里,用于获取类的成员属性，或执行类的成员方法</p>
    <h3>self::</h3>
    <p>对本类的引用 ，用于获取当前类的静态成员属性或静态成员方法  self::run()</p>
    <h3>parent::</h3>
    <p>对父类的引用,调用父类的方法或属性。</p>
    <h2><a>抽象类</a></h2>
    <p>具有抽象方法的类为抽象类，抽象方法即为没有内容的空方法，要求子类  进行完善内容，抽象类不能实例化，只能继承，通过extends来实现，抽  象类中也可以定义普通方法,父类方法执行方式不确定，但子类还都有这个方法。</p>
    <p>例如：定义动物类，每个动物都有叫声方法，但是表面不同，所以要  定义为抽象类，让每种动物类去实现功能。</p>
    <p>当父类为抽象类时，子类必须重写父类的抽象方法抽象类里不一定非要写抽象方法，但有抽象方法的类必须定义为抽象类,抽象类必须继承使用抽象方法不能有主体即{}</p>
    <pre><code><?php echo htmlspecialchars('
<?php
abstract class AbstractClass
{
    // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
    print $this->getValue();
    }
}
/**
* 子类-继承了抽象类
*/
class Car extends AbstractClass
{
    protected function getValue(){

    }
    protected function prefixValue($prefix){
        
    }
}
?>') ?></code></pre>
    <h2><a>接口</a></h2>
    <p>使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。接口中定义的所有方法都必须是公有，这是接口的特性。要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。</p>
    <pre><code><?php echo htmlspecialchars('
<?php
interface DbInterface {
    public function connectDb(); //获得连接  
    public function close(); //关闭数据库
    public function exe($sql); //发送没有返回值的sql  
    public function query($sql); //有返回值的sql
}
class Db implements DbInterface
{
    public function exe($sql){
    }
    public function query($sql{
    }
}
?>') ?></code></pre>
    <h3>接口与抽象类的区别：</h3>
    <ol>
        <li>接口只能用implements实现   抽象类用extends继承实现</li><p></p>
        <li> 接口中不可以有成员方法，抽象类可以有成员方法</li><p></p>
        <li>接口没有构造函数，抽象类可以定义构造函数</li><p></p>
        <li>接口方法都是public 抽象类方法可以用protected private public来修饰  </li><p></p>
        <li>一个类可以实现多个接口，但只能继承一个抽象类</li>
    </ol>
    <h2><a>魔术常量 </a></h2>
    <table>
        <caption>
            <strong>
                几个 PHP 的“魔术常量”
            </strong>
        </caption>
        <thead>
            <tr>
                <th>
                    名称
                </th>
                <th>
                    说明
                </th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>
                    <strong>
                        <code>__LINE__</code>
                    </strong>
                </td>
                <td>
                    文件中的当前行号。
                </td>
            </tr>
            <tr>
                <td>
                    <strong>
                        <code>__FILE__</code>
                    </strong>
                </td>
                <td>
                    文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。自 PHP 4.0.2 起，
                    <strong>
                        <code>__FILE__</code>
                    </strong>
                    总是包含一个绝对路径（如果是符号连接，则是解析后的绝对路径），而在此之前的版本有时会包含一个相对路径。
                </td>
            </tr>
            <tr>
                <td>
                    <strong>
                        <code>__DIR__</code>
                    </strong>
                </td>
                <td>
                    文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于
                    <em>
                        dirname(__FILE__)
                    </em>
                    。除非是根目录，否则目录中名不包括末尾的斜杠。（PHP 5.3.0中新增） =
                </td>
            </tr>
            <tr>
                <td>
                    <strong>
                        <code>__CLASS__</code>
                    </strong>
                </td>
                <td>
                    类的名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该类被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。类名包括其被声明的作用区域（例如
                    <em>
                        Foo\Bar
                    </em>
                    ）。注意自 PHP 5.4 起 __CLASS__ 对 trait 也起作用。当用在 trait 方法中时，__CLASS__ 是调用 trait
                    方法的类的名字。
                </td>
            </tr>
            <tr>
                <td>
                    <strong>
                        <code>__METHOD__</code>
                    </strong>
                </td>
                <td>
                    类的方法名（PHP 5.0.0 新加）。返回该方法被定义时的名字（区分大小写）。
                </td>
            </tr>
        </tbody>
    </table>
    <h2><a>魔术方法</a></h2>
    <table>
        <thead>
            <tr>
                <th>
                    名称
                </th>
                <th>
                    说明
                </th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td><code>__isset()</code></td>
                <td>检测对象里面的私有成员属性是否存在</td> 
            </tr>
            <tr>
                <td><code>__unset()</code></td>
                <td>是个共有的方法，用来删除对象里的私有成员属性</td> 
            </tr>
            <tr>
                <td><code>__get()</code></td>
                <td>获取对象未定义的属性时，自动运行的魔术函数</td> 
            </tr>
            <tr>
                <td><code>__set()</code></td>
                <td>给未定义的属性赋值时，自动运行的魔术函数。可以将set设置的未定义属性存到类的数组类型成员属性，get时再找相应变量索引</td> 
            </tr>
            <tr>
                <td><code>__call()</code></td>
                <td>调用一个未定义的方法时，自动执行的魔术函数，2个参数 1方法名  2参数数组</td> 
            </tr>
            <tr>
                <td><code>__autoload($className)</code></td>
                <td>引用一个类时自动执行的函数，可以读入类文件，可以通过  spl_autoload_register(array('a','run'));
                来指定新的魔术函数。</td> 
            </tr>
        </tbody>
    </table>
    <h3>作业</h3>
    <blockquote>通过面向对象思想实现文件上传类Upload.class.php</blockquote>
</article>